package com.anfeng.cms.service.impl.emp;

import com.anfeng.cms.common.Common;
import com.anfeng.cms.domain.emp.AfEmployeePhoto;
import com.anfeng.cms.domain.emp.AfGuestInfo;
import com.anfeng.cms.repository.mysql.dao.emp.AfGuestInfoMapper;
import com.anfeng.cms.request.emp.GuestInfoReq;
import com.anfeng.cms.service.emp.IAfGuestInfoService;
import com.anfeng.cms.service.emp.UploadImageService;
import com.anfeng.cms.util.IdGeneratorUtil;
import com.anfeng.cms.util.JsonMapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 吴朋
 * @since 2019-07-15
 */
@Service
@Slf4j
public class AfGuestInfoServiceImpl extends ServiceImpl<AfGuestInfoMapper, AfGuestInfo> implements IAfGuestInfoService {

    @Autowired
    private UploadImageService uploadImageService;

    /**
     * 新增访客信息
     *
     * @param guestInfo 访客信息
     * @return 访客信息id
     */
    @Override
    public String addGuestInfo(AfGuestInfo guestInfo) {
        if (null == guestInfo) {
            log.error("新增访客信息失败 传入参数为空");
            return null;
        }
        // 先根据访客手机号 查询是否存在访客信息
        AfGuestInfo dbGuest= this.getGuestInfoByMobile(guestInfo.getMobile());
        // 如果不存在的话  就新建
        String guestId;
        Date currentDate = new Date();
        if (null == dbGuest) {
            guestId = IdGeneratorUtil.uuid();
            dbGuest = new AfGuestInfo();
            dbGuest.setId(guestId);
            dbGuest.setName(guestInfo.getName());
            dbGuest.setGender(guestInfo.getGender());
            dbGuest.setMobile(guestInfo.getMobile());
            dbGuest.setIdentityNo(guestInfo.getIdentityNo());
            dbGuest.setEmpId(guestInfo.getEmpId());
            dbGuest.setEmpMobile(guestInfo.getEmpMobile());
            dbGuest.setPhotoId(guestInfo.getPhotoId());
            dbGuest.setEmpName(guestInfo.getEmpName());
            dbGuest.setState(Common.DATA_STATE_NORMAL);
            dbGuest.setCreateTime(currentDate);
            dbGuest.setModifiedTime(currentDate);
            boolean result = this.insert(dbGuest);
            if (!result) {
                log.error("新增访客信息失败 {}", JsonMapper.defaultMapper().toJson(dbGuest));
                return null;
            }
        } else {
            // 更新访客信息
            guestId = dbGuest.getId();
            //更新被访者信息
            dbGuest.setEmpId(guestInfo.getEmpId());
            dbGuest.setEmpName(guestInfo.getEmpName());
            dbGuest.setEmpMobile(guestInfo.getEmpMobile());
            dbGuest.setModifiedTime(currentDate);
            boolean update = this.updateById(dbGuest);
            if (!update) {
                log.error("更新访客信息失败 {}", JsonMapper.defaultMapper().toJson(dbGuest));
                return null;
            }
        }

        return guestId;
    }

    /**
     * 根据访客手机号 查询是否存在访客记录信息
     *
     * @param mobile 访客手机号
     * @return 是否存在访客信息
     */
    @Override
    public AfGuestInfo getGuestInfoByMobile(String mobile) {
        if (StringUtils.isBlank(mobile)) {
            log.error("根据手机号查询访客记录信息 失败 传入 参数不能为空");
            return null;
        }
        GuestInfoReq infoReq = new GuestInfoReq();
        infoReq.setMobile(mobile);
        EntityWrapper<AfGuestInfo> wrapper = this.generatorWrapper(infoReq);
        return this.selectOne(wrapper);
    }

    /**
     * 根据查询条件获取访客信息
     *
     * @param guestInfoReq 查询访客信息
     * @return 访客信息
     */
    @Override
    public List<AfGuestInfo> getAllGuestInfos(GuestInfoReq guestInfoReq) {
        EntityWrapper<AfGuestInfo> wrapper = this.generatorWrapper(guestInfoReq);
        return this.selectList(wrapper);
    }

    /**
     * 根据查询条件获取访客数量
     *
     * @param guestInfoReq 查询条件
     * @return 访客数量
     */
    @Override
    public int getAllGuestInfoCounts(GuestInfoReq guestInfoReq) {
        EntityWrapper<AfGuestInfo> wrapper = this.generatorWrapper(guestInfoReq);
        return this.selectCount(wrapper);
    }

    /**
     * 分页查询访客信息
     *
     * @param guestInfoReq 查询条件
     * @param page         页数
     * @param pageSize     每页数量
     * @return 获取信息
     */
    @Override
    public List<AfGuestInfo> getGuestInfoByPage(GuestInfoReq guestInfoReq, Integer page, Integer pageSize) {
        if (page == null || page < 1) {
            page = 1;
        }
        if (pageSize == null || pageSize < 10) {
            pageSize = 10;
        }
        Page<AfGuestInfo> infoPage = new Page<>();
        infoPage.setCurrent(page);
        infoPage.setSize(pageSize);

        EntityWrapper<AfGuestInfo> wrapper = this.generatorWrapper(guestInfoReq);
        Page<AfGuestInfo> guestInfoPage = this.selectPage(infoPage, wrapper);
        if (null == guestInfoPage || null == guestInfoPage.getRecords() || guestInfoPage.getRecords().isEmpty()) {
            return Collections.EMPTY_LIST;
        }
        return guestInfoPage.getRecords();
    }

    /**
     * 根据访客id 更新访客照片
     *
     * @param guestId 访客id
     * @param photoId 照片id
     * @return 是否成功 -1 失败 1 成功
     */
    @Override
    public int updateGuestPhoto(String guestId, String photoId) {
        if (StringUtils.isBlank(guestId) || StringUtils.isBlank(photoId)) {
            log.error("修改访客照片 传入参数不正确");
            return Common.RETURN_FAILED;
        }
        // 根据id查询访客信息
        AfGuestInfo guestInfo = this.selectById(guestId);
        if (null == guestId || guestInfo.getState() == Common.DATA_STATE_DELETE) {
            log.error("根据访客Id 未查询到相关访客记录 {}", guestId);
            return Common.RETURN_FAILED;
        }
        // 查看照片信息是否正确
        AfEmployeePhoto employeePhoto = uploadImageService.getImageById(photoId);
        if (null == employeePhoto || employeePhoto.getState() == Common.DATA_STATE_DELETE || StringUtils.isBlank(employeePhoto.getGuestId())) {
            log.error("修改访客照片出错  根据传入的照片id {} 未查询到相关照片信息", photoId);
            return Common.RETURN_FAILED;
        }
        guestInfo.setPhotoId(photoId);
        guestInfo.setModifiedTime(new Date());
        boolean result = this.updateById(guestInfo);
        if (!result) {
            log.error("更新访客照片出错 访客信息是： {}", JsonMapper.defaultMapper().toJson(guestInfo));
            return Common.RETURN_FAILED;
        }
        return Common.RETURN_SUCCESS;
    }

    /**
     * 修改访客状态 是否禁用 （1 启用 2 禁用）
     *
     * @param guestId 访客id
     * @param state   状态 是否启用
     * @return 是否修改成功 -1 失败 1 成功
     */
    @Override
    public int updateGuestInfoState(String guestId, Integer state) {
        if (StringUtils.isBlank(guestId) || null == state || (state != Common.DATA_STATE_NORMAL && state != Common.DATA_STATE_DELETE)) {
            log.error("修改访客是否禁用状态 传入参数有误");
            return Common.RETURN_FAILED;
        }
        // 获取用户信息
        AfGuestInfo guestInfo = this.selectById(guestId);
        if (null == guestInfo) {
            log.error("未查询到相关访客信息 {}", guestId);
            return Common.RETURN_FAILED;
        }
        //判断禁用状态是否一致
        if (guestInfo.getState().equals(state)) {
            return Common.RETURN_SUCCESS;
        }
        // 不一致进行修改
        guestInfo.setState(state);
        guestInfo.setModifiedTime(new Date());
        boolean update = this.updateById(guestInfo);
        if (!update) {
            log.error("更新访客 用户是否禁用状态失败 {}", JsonMapper.defaultMapper().toJson(guestInfo));
            return Common.RETURN_FAILED;
        }
        return Common.RETURN_SUCCESS;
    }

    /**
     * 根据查询条件生成 wrapper
     * @param infoReq 查询条件
     * @return wrapper
     */
    private EntityWrapper<AfGuestInfo> generatorWrapper(GuestInfoReq infoReq) {
        AfGuestInfo guestInfo = new AfGuestInfo();
        guestInfo.setName(infoReq.getName());
        guestInfo.setMobile(infoReq.getMobile());
        guestInfo.setIdentityNo(infoReq.getIdentityNo());

        EntityWrapper<AfGuestInfo> wrapper = new EntityWrapper<>();
        wrapper.setEntity(guestInfo);
        wrapper.orderBy("create_time", false);
        return wrapper;
    }
}
